home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 July: Mac OS SDK / Dev.CD Jul 96 SDK / Dev.CD Jul 96 SDK2.toast / Development Kits (Disc 2) / QuickDraw GX / Programming Stuff / Sample Code / Printing Samples / Printer Drivers… / ImageWriterLQ (alt. rdip) / DialogRoutines.c < prev    next >
Encoding:
Text File  |  1995-04-10  |  22.1 KB  |  812 lines  |  [TEXT/MPS ]
  1. /*---------------------------------------------------------------------------
  2. FILENAME
  3.     DialogRoutines.c
  4.  
  5. DESCRIPTION
  6.     This file contains the routines which are used to process the LQ driver's
  7.     sheetfeeder dialog.
  8.         
  9. COPYRIGHT
  10.     Copyright Apple Computer, Inc. 1992-1994
  11.     All rights reserved. 
  12.     
  13. INTERFACE ROUTINES:
  14.     DoSheetfeederDialog
  15.  
  16.     12/20/93        dmh                Sync'd with the shipping 1.0b3 GX driver.
  17.      8/28/94        dmh                Sync'd with the shipping 1.0.1 GX driver.
  18.  
  19. -------------------------------------------------------------------------------- */
  20.  
  21. // Include the standard Mac header files 
  22. #include "MacIncludes.h"
  23.  
  24. // Include the new QuickDraw GX graphics header files 
  25. #include <graphics routines.h>
  26. #include <graphics libraries.h>
  27. #include <math routines.h>
  28. #include <qd library.h>
  29.  
  30. // Include the required Printing Manager header files 
  31. #include <PrintingManager.h>
  32. #include <PrintingMessages.h>
  33. #include <PrintingDrivers.h>
  34. #include <Collections.h>
  35. #include <Messages.h>
  36. #include <PrintingResTypes.h>
  37. #include <PrintingErrors.h>
  38.  
  39. #include <GXExceptions.h>
  40.  
  41. // Include the internal driver constants and types used by this module 
  42. #include "Resources.h"
  43. #include "UniversalMessageIntf.h"
  44. #include "DialogRoutines.h"
  45.  
  46.  
  47. /***************************************************************************************
  48. *                                                 CONSTANTS                                                         *
  49. ***************************************************************************************/                        
  50.  
  51. // Constants for accessing items in the Sheetfeeder dialog
  52.  
  53. #define    kTray1Item                4            //    Tray #1 pop-up menu
  54. #define    kTray2Item                5            //    Tray #2 pop-up menu
  55. #define    kTray3Item                6            //    Tray #3 pop-up menu
  56. #define    kPrinterPICTItem        7            //    Picture of the printer with a sheetfeeder
  57.  
  58. // Constants useful for filtering events
  59.  
  60. #define    kENTER                    0x03        // ENTER character
  61. #define    kCR                        0x0D        // Carriage return character
  62.  
  63. // Constants defining the maximum paper size supported by the LQ printer
  64.  
  65. #define    kMaxPaperWidth            ff(15)    // 15 inches is maximum width
  66. #define    kMaxPaperHeight        ff(69)    // 69 inches is maximum height
  67.  
  68.  
  69. /*********************************************************************************
  70.  *                                             TYPES                                                     *
  71.  *********************************************************************************/
  72.  
  73. // PopupMenuInfo - Structure used to initialize the tray pop-up menus 
  74.  
  75. typedef struct
  76. {
  77.     short                numTrays;        // Number of trays configured on the printer 
  78.     MenuHandle        tray1Menu;        //    handle to the tray #1 pop-up menu
  79.     MenuHandle        tray2Menu;        //    handle to the tray #2 pop-up menu
  80.     MenuHandle        tray3Menu;        //    handle to the tray #3 pop-up menu
  81. }    PopupMenuInfo,
  82.     *PopupMenuInfoPtr;
  83.     
  84.     
  85. // PaperSearchRec - Structure used to search for a paper type chosen from a pop-up menu
  86.  
  87. typedef struct
  88. {
  89.     gxPaperType        paper;            // temp. paper type reference in which to return found paper type 
  90.     Str31                paperName;        //    name of the paper to locate
  91. }    PaperSearchRec,
  92.     *PaperSearchRecPtr;
  93.     
  94.  
  95. /***************************************************************************************
  96. *                                         INLINE ROUTINES                                                         *
  97. ***************************************************************************************/                        
  98.  
  99. pascal void QDDrawPicture(PicHandle myPicture,const Rect *dstRect) = 0xA8F6;
  100.  
  101.  
  102. /***************************************************************************************
  103. *                                         INTERNAL ROUTINES                                                     *
  104. ***************************************************************************************/                        
  105.  
  106.  
  107. /****************************************************************************************
  108.  
  109.                             FindChosenPaperType
  110.                             
  111.     function:
  112.                 This routine is called by ForEachPaperTypeDo, and it searches for a specific
  113.                 paper type (by name).  It terminates searching when the paper type is 
  114.                 found.  Only the names of paper that will fit into the printer will be considered.
  115.  
  116.                 
  117.     parameters:                
  118.                 paper                target paper type
  119.                 paperToFind        structure that identifies the paper type to find
  120.                 
  121.     returns:
  122.                 LoopStatus        keepLooping => keep examining paper types
  123.                                     stopLooping    => no longer loop - we found the one we wanted
  124.     
  125. ****************************************************************************************/
  126. pascal gxLoopStatus FindChosenPaperType(gxPaperType paper, PaperSearchRecPtr paperToFind)
  127. {
  128.     Str31                paperName;
  129.     gxLoopStatus    status = gxKeepLooping;
  130.     gxRectangle        paperSize;
  131.     
  132.     // Get the dimensions of the paper
  133.     GXGetPaperTypeDimensions(paper, nil, &paperSize);
  134.     
  135.     // Will the paper fit into the printer?
  136.     if (    ( (paperSize.right - paperSize.left) <= FixMul(ff(72), kMaxPaperWidth) )    &&
  137.             ( (paperSize.bottom - paperSize.top) <= FixMul(ff(72), kMaxPaperHeight) )
  138.         )
  139.     {
  140.         // Retrieve the name of the paper type
  141.         GXGetPaperTypeName(paper, paperName);
  142.     
  143.         if ( IUCompString(paperName, paperToFind->paperName) == 0 )    //    T => Found the paper type
  144.         {
  145.             // Make a copy of this paper type and quit searching
  146.             GXCopyPaperType (paper, paperToFind->paper);
  147.             status = gxStopLooping;
  148.         }
  149.     }
  150.         
  151.     return(status);
  152. } 
  153. /* FindChosenPaperType */
  154.  
  155.  
  156. /****************************************************************************************
  157.  
  158.                             SaveSheetfeederSettings
  159.                             
  160.     function:
  161.                 This routine is called if the user confirms the changes in the dialog.  It
  162.                 stores updates the tray information configuration file with the user's latest
  163.                 settings.
  164.                 
  165.     parameters:                
  166.                 theDlog        pointer to the target dialog
  167.                 menuStuff    info. about the pop-up menus
  168.                 
  169.     returns:
  170.                 OSErr            error code
  171.     
  172. ****************************************************************************************/
  173. OSErr SaveSheetfeederSettings(DialogPtr theDlog, PopupMenuInfoPtr menuStuff)
  174. {
  175.     OSErr            anErr;
  176.     gxPaperType    paper;
  177.     gxJob            theJob = GXGetJob();
  178.     MenuHandle    *nextMenu;
  179.     short            i;
  180.     
  181.     // Create a temporary paper type
  182.     
  183.     paper = GXNewPaperType(theJob, NULL, NULL, NULL);
  184.     anErr = GXGetJobError(theJob);
  185.     require(anErr == noErr, NewPaperType);
  186.     
  187.     // For each visible pop-up menu, update its associated tray information
  188.     
  189.     for (i = kTray1Item, nextMenu = &(menuStuff->tray1Menu); i <= kTray3Item; ++i, ++nextMenu )
  190.     {
  191.         short        whichTray = i - kTray1Item + 1;
  192.         
  193.         if ( whichTray <= menuStuff->numTrays )    //    T => This menu is visible
  194.         {
  195.             Str31                    paperName;
  196.             short                    itemType;
  197.             ControlHandle        item;
  198.             Rect                    itemRect;
  199.             PaperSearchRec        paperToFind;
  200.             
  201.             // Get the name of the chosen paper type from the menu
  202.             
  203.             GetDItem(theDlog, i, &itemType, (Handle *) &item, &itemRect);
  204.             GetItem(*nextMenu, GetCtlValue(item), paperName);
  205.  
  206.             // Get the tray information for this tray
  207.             
  208.             anErr = GXGetTrayPaperType(whichTray, paper);
  209.             if (anErr == resNotFound)
  210.                 anErr = noErr;
  211.             require(anErr == noErr, GetTrayPaperType);
  212.         
  213.             //    Get the referenced paper type
  214.  
  215.             paperToFind.paper = paper;
  216.             BlockMove((Ptr) paperName, (Ptr) paperToFind.paperName, sizeof(Str31));
  217.             
  218.             GXForEachJobPaperTypeDo(theJob, FindChosenPaperType, &paperToFind, false);        // Don't consider the format device in this search    
  219.             anErr = GXGetJobError(theJob);
  220.             require(anErr == noErr, ForEachPaperTypeDo);
  221.             
  222.             // Update the paper type for this tray
  223.             
  224.             anErr = GXSetTrayPaperType(whichTray, paper);
  225.             require(anErr == noErr, SetTrayPaperType);
  226.             
  227.         }
  228.         else    //     T => No more visible pop-up menus
  229.             break;
  230.     }
  231.  
  232.  
  233. /******* Clean-up *******/
  234.  
  235. SetTrayPaperType:
  236. GetTrayPaperType:
  237. ForEachPaperTypeDo:
  238.     GXDisposePaperType(paper);
  239.  
  240. NewPaperType:
  241.     return(anErr);
  242. }
  243. /* SaveSheetfeederSettings */
  244.  
  245.  
  246. /****************************************************************************************
  247.  
  248.                             SheetfeederDialogFilter
  249.                             
  250.     function:
  251.                 This routine is the filter proc. that is passed to ModalDialog when the 
  252.                 sheetfeeder dialog is displayed.  It filters for the <cr> and <enter> keys
  253.                 and for command-".".
  254.                 
  255.     parameters:                
  256.                 theDlog        pointer to the target dialog
  257.                 theEvent        the event to be filtered
  258.                 itemHit        the item which was selected; may be mapped to ok or cancel
  259.                 
  260.     returns:
  261.                 Boolean        true if we've filtered the event; false if ModalDialog should process it
  262.     
  263. ****************************************************************************************/
  264. pascal Boolean SheetfeederDialogFilter(DialogPtr theDlog, EventRecord *theEvent, short *itemHit)
  265. {
  266.     Boolean    eventFiltered = false;
  267.     short        itemType;
  268.     Rect        itemRect;
  269.     Handle    item;
  270.     
  271.     if ( (theEvent->what == keyDown) || (theEvent->what == autoKey) ) 
  272.     {
  273.         char        c;
  274.         
  275.         c = (char) (theEvent->message & charCodeMask);
  276.         
  277.         if ( (c == kCR) || (c == kENTER) )     //    T => User typed carriage return or enter key; filter event
  278.         {
  279.             *itemHit = ok;
  280.             eventFiltered = true;
  281.         }
  282.         else
  283.         if ( (c == '.') && ((theEvent->modifiers & cmdKey) != 0) )    //    T => User typed <cmnd>-"."
  284.         {
  285.             *itemHit = cancel;
  286.             eventFiltered = true;
  287.         }
  288.         
  289.         if (eventFiltered)    //    T => Highlight the buttons appropriately
  290.         {
  291.             ControlHandle    theCtrl;
  292.             long                ignore;
  293.             
  294.             // Highlight the OK button momentarily
  295.             
  296.             GetDItem(theDlog, *itemHit, &itemType, (Handle *) &theCtrl, &itemRect);
  297.             HiliteControl(theCtrl, inButton);
  298.             Delay(10, &ignore);
  299.             HiliteControl(theCtrl, 0);
  300.         }
  301.     }
  302.     else
  303.     if (theEvent->what == updateEvt)    //    T => Outline the OK button
  304.     {
  305.         GrafPtr    oldPort;
  306.         
  307.         GetPort(&oldPort);
  308.         SetPort(theDlog);
  309.         
  310.         GetDItem(theDlog, ok, &itemType, &item, &itemRect);
  311.         PenSize(3, 3);
  312.         InsetRect(&itemRect, -4, -4);
  313.         FrameRoundRect(&itemRect, 16, 16);
  314.         PenNormal();
  315.  
  316.         SetPort(oldPort);
  317.     }
  318.  
  319.     return(eventFiltered);
  320. }
  321. /* SheetfeederDialogFilter */
  322.  
  323.  
  324. /****************************************************************************************
  325.  
  326.                             UniquePaperName
  327.                             
  328.     function:
  329.                 This routine searches for a specified paper type name in a specific pop-up
  330.                 menu.  If it finds the name, the routine returns false; otherwise it
  331.                 returns true.
  332.                 
  333.     parameters:                
  334.                 hMenu            handle to the menu to examine
  335.                 paperName    name of the paper type to insert to check for
  336.                 
  337.     returns:
  338.                 Boolean        true if paper type name is unique; false otherwise
  339.     
  340. ****************************************************************************************/
  341. Boolean UniquePaperName(MenuHandle hMenu, Str31 paperName)
  342. {
  343.     Boolean    isUnique = true;
  344.     short        i;
  345.     Str255    menuString;
  346.     
  347.     for (i = CountMItems(hMenu); i > 0; --i) 
  348.     {
  349.         GetItem(hMenu, i, menuString);
  350.         
  351.         if ( IUCompString(paperName, menuString) == 0 )     //    T => Found the string
  352.         {
  353.             isUnique = false;
  354.             break;
  355.         }
  356.     }
  357.     
  358.     return(isUnique);
  359. }  
  360. /* UniquePaperName */
  361.  
  362.  
  363. /****************************************************************************************
  364.  
  365.                             AddPaperName
  366.                             
  367.     function:
  368.                 This routine is called by ForEachPaperTypeDo, and it adds a paper name to 
  369.                 each visible pop-up menu if the name does not already appear in the menu.
  370.                 Only the names of paper that will fit into the printer will be listed
  371.                 in the pop-up menu.
  372.                 
  373.     parameters:                
  374.                 paper                target paper type
  375.                 menuStuff        pointer to info about the dialog's pop-up menus
  376.                 
  377.     returns:
  378.                 LoopStatus        keepLooping => examine all target paper types
  379.     
  380. ****************************************************************************************/
  381. pascal gxLoopStatus AddPaperName(gxPaperType paper, PopupMenuInfoPtr menuStuff)
  382. {
  383.     Str31            paperName;
  384.     gxRectangle    paperSize;
  385.     
  386.     // Get the dimensions of the paper
  387.     GXGetPaperTypeDimensions(paper, nil, &paperSize);
  388.     
  389.     // Will the paper fit into the printer?
  390.     if (    ( (paperSize.right - paperSize.left) <= FixMul(ff(72), kMaxPaperWidth) )    &&
  391.             ( (paperSize.bottom - paperSize.top) <= FixMul(ff(72), kMaxPaperHeight) )
  392.         )
  393.     {
  394.         // Retrieve the name of the paper type
  395.         GXGetPaperTypeName(paper, paperName);
  396.     
  397.         if ( UniquePaperName(menuStuff->tray1Menu, paperName) )    //    T => If the paper name is unique, add it
  398.         {
  399.             MenuHandle        *nextMenu;
  400.             Str255            theName;
  401.             short                i;
  402.             
  403.             // For each visible menu, add the name to the pop-up
  404.             
  405.             for (i = kTray1Item, nextMenu = &(menuStuff->tray1Menu); i <= kTray3Item; ++i, ++nextMenu )
  406.             {
  407.                 if ( (i - kTray1Item + 1) <= menuStuff->numTrays )    //    T => This menu is visible
  408.                 {
  409.                     AppendMenu(*nextMenu, "\p ");
  410.                     BlockMove(paperName, theName, sizeof(Str31));
  411.                     SetItem(*nextMenu, CountMItems(*nextMenu), theName);
  412.                 }
  413.                 else    //     T => No more visible pop-up menus
  414.                     break;
  415.             }
  416.         }
  417.     }
  418.         
  419.     return (gxKeepLooping);
  420. } 
  421. /* AddPaperName */
  422.  
  423.  
  424. /****************************************************************************************
  425.  
  426.                             LoadPaperNames
  427.                             
  428.     function:
  429.                 This routine loads the names of each uniquely named paper type into each of the
  430.                 tray pop-up menus that are still visible.
  431.                 
  432.     parameters:                
  433.                 pDlg            Pointer to the target dialog
  434.                 whichItem    Index in the DITL of the item to draw
  435.                 
  436.     returns:
  437.                 OSErr            error code
  438.     
  439. ****************************************************************************************/
  440. OSErr LoadPaperNames(DialogPtr theDlog, PopupMenuInfoPtr menuStuff)
  441. {
  442.     short                itemType;
  443.     Rect                itemRect;
  444.     ControlHandle    item;
  445.     short                i;
  446.     gxJob                theJob = GXGetJob();
  447.     OSErr                anErr;
  448.  
  449.     GXForEachJobPaperTypeDo(theJob,  AddPaperName,  menuStuff, false);        // Don't consider the format device in this search    
  450.     anErr = GXGetJobError(theJob);
  451.  
  452.     if (anErr == noErr)
  453.     {
  454.         MenuHandle        *nextMenu;
  455.         
  456.         // For each visible menu, initialize the pop-up control
  457.         
  458.         for (i = kTray1Item, nextMenu = &(menuStuff->tray1Menu); i <= kTray3Item; ++i, ++nextMenu )
  459.         {
  460.             if ( (i - kTray1Item + 1) <= menuStuff->numTrays )    //    T => This menu is visible
  461.             {
  462.                 GetDItem(theDlog, i, &itemType, (Handle *) &item, &itemRect);
  463.                 
  464.                 SetCtlMin(item, 1);
  465.                 SetCtlMax(item, CountMItems(*nextMenu));
  466.                 SetCtlValue(item, 1);
  467.             }
  468.             else    //     T => No more visible pop-up menus
  469.                 break;
  470.         }
  471.     }
  472.  
  473.     return(anErr);
  474. }
  475. /* LoadPaperNames */
  476.  
  477.  
  478. /****************************************************************************************
  479.  
  480.                             SheetfeederDrawProc
  481.                             
  482.     function:
  483.                 This routine is used to draw the picture of the sheetfeeder in the configuration
  484.                 dialog.
  485.                 
  486.     parameters:                
  487.                 pDlg            Pointer to the target dialog
  488.                 whichItem    Index in the DITL of the item to draw
  489.                 
  490.     returns:
  491.                 OSErr            error code
  492.     
  493. ****************************************************************************************/
  494. pascal void SheetfeederDrawProc(WindowPtr    pDlg, short whichItem)
  495. {
  496.     SpecGlobalsHdl     hGlobals = GetMessageHandlerInstanceContext();
  497.     Handle                hItem;
  498.     Rect                    itemRect;
  499.     short                    itemType;
  500.     
  501.     GetDItem(pDlg, whichItem, &itemType, &hItem, &itemRect);
  502.  
  503.     QDDrawPicture((*hGlobals)->sheetFeederPICT, &itemRect);
  504. }
  505. /* SheetfeederDrawProc */
  506.  
  507.  
  508. /****************************************************************************************
  509.  
  510.                             GetConfigInfo
  511.                             
  512.     function:
  513.                 This routine is a utility function that returns the LQ driver's configuration
  514.                 info. from the desktop printer file.
  515.                 
  516.     parameters:                
  517.                 configInfo    Latest info fetched from the DTP file
  518.                 
  519.     returns:
  520.                 OSErr            error code
  521.     
  522. ****************************************************************************************/
  523. OSErr GetConfigInfo(IWLQConfigInfoPtr configInfo)
  524. {
  525.     OSErr                        anErr;
  526.     Str32                        deviceName;
  527.     IWLQConfigInfoHdl        hConfigData;
  528.     
  529.     // Get the name of the desktop printer file
  530.     GXGetPrinterName(GXGetJobOutputPrinter(GXGetJob()), deviceName);
  531.  
  532.     // Get the config info
  533.     anErr = GXFetchDTPData(deviceName, kIWLQConfigType, kIWLQConfigID, (Handle *) &hConfigData);
  534.     require(anErr == noErr, FetchDTPData);
  535.     
  536.     // Return the config. info
  537.     *configInfo = **hConfigData;
  538.     
  539.     // Kill the temporary handle
  540.     DisposHandle((Handle) hConfigData);
  541.     
  542.  
  543. /******* Clean-up *******/
  544.  
  545. FetchDTPData:
  546.     return(anErr);
  547. }
  548. /* GetConfigInfo */
  549.  
  550.  
  551. /****************************************************************************************
  552.  
  553.                             InitSheetfeederDialog
  554.                             
  555.     function:
  556.                 This routine is called to initialize the sheet feeder dialog and to set the
  557.                 state of the pop-up menus based upon the latest configuration information.
  558.                 
  559.     parameters:                
  560.                 theDlog        returns the pointer to the dialog window if init. was succesful; otherwise nil
  561.                 menuStuff    info about the dialog's pop-up menus
  562.                 
  563.     returns:
  564.                 OSErr        error code
  565.     
  566. ****************************************************************************************/
  567. OSErr InitSheetfeederDialog(DialogPtr *theDlog, PopupMenuInfoPtr menuStuff)
  568. {
  569.     OSErr                    anErr = noErr;
  570.     DialogPtr            dLog;
  571.     IWLQConfigInfo        configInfo;
  572.     SpecGlobalsHdl     hGlobals = GetMessageHandlerInstanceContext();
  573.     short                    itemType;
  574.     Rect                    itemRect;
  575.     Handle                hItem;
  576.     gxPaperType            paper;
  577.     
  578.     // Initialize variables
  579.     *theDlog = nil;
  580.     (*hGlobals)->sheetFeederPICT = nil;
  581.     
  582.     dLog = GetNewDialog(kSheetFeederDLOG, nil, (WindowPtr) (-1));
  583.     if (dLog == nil)
  584.     {
  585.         anErr = MemError();
  586.         if (anErr == noErr)
  587.             anErr = resNotFound;
  588.         
  589.         require(anErr == noErr, GetNewDialog);
  590.     }
  591.  
  592.     // Fetch the latest configuration info. from the DTP file
  593.     anErr = GetConfigInfo(&configInfo);
  594.     require(anErr == noErr, GetConfigInfo);
  595.     
  596.     // Determine which sheetfeeder picture to display in the dialog
  597.     {
  598.         short            whichPICT;
  599.         Handle        thePICT;
  600.         
  601.         switch (configInfo.numTrays)
  602.         {
  603.             case 1:    whichPICT = kOneTrayPICT;         break;
  604.             case 2:    whichPICT = kTwoTrayPICT;         break;
  605.             case 3:    whichPICT = kThreeTrayPICT;     break;
  606.         }
  607.         
  608.         anErr = Send_GXFetchTaggedDriverData('PICT', whichPICT, (Handle *) &thePICT);
  609.         require(anErr == noErr, FetchTaggedDriverData);
  610.         
  611.         // Save this handle in our globals
  612.  
  613.         HNoPurge(thePICT);
  614.         (*hGlobals)->sheetFeederPICT = (PicHandle) thePICT;
  615.         
  616.         // Setup the DrawProc for this picture item
  617.         
  618.         GetDItem(dLog, kPrinterPICTItem, &itemType, &hItem, &itemRect);
  619.         SetDItem(dLog, kPrinterPICTItem, itemType, (Handle) SheetfeederDrawProc, &itemRect);
  620.     }
  621.     
  622.     // Now fill in the pop-up menu paper type names and hide any pop-ups that don't apply
  623.     // to the current configuration
  624.     {
  625.         PopupPrivateDataHandle    privData;
  626.         short                            i;
  627.         MenuHandle                    *nextMenu;
  628.         
  629.         // Hide those pop-ups which don't apply to the current configuration
  630.         if (configInfo.numTrays < 3)
  631.         {
  632.             HideDItem(dLog, kTray3Item);
  633.         }
  634.  
  635.         if (configInfo.numTrays < 2)
  636.         {
  637.             HideDItem(dLog, kTray2Item);
  638.         }
  639.         
  640.         // Init. the menuStuff structure in order to load the paper names into the pop-ups
  641.         
  642.         menuStuff->numTrays = configInfo.numTrays;
  643.  
  644.         for (i = kTray1Item, nextMenu = &(menuStuff->tray1Menu); i <= kTray3Item; ++i, ++nextMenu)
  645.         {
  646.             GetDItem(dLog, i, &itemType, &hItem, &itemRect);
  647.             privData = (PopupPrivateDataHandle) (* (ControlHandle) hItem)->contrlData;
  648.             *nextMenu = (*privData)->mHandle;
  649.         }
  650.         
  651.         // Now load the paper type names into the remaining pop-up menus
  652.         anErr = LoadPaperNames(dLog, menuStuff);
  653.         require(anErr == noErr, LoadPaperNames);
  654.     }
  655.     
  656.     // Retrieve the latest paper<->tray configuration and force the pop-up(s) to display the
  657.     // correct paper name (i.e. the last selected paper name).
  658.     {
  659.         gxJob            theJob = GXGetJob();
  660.         MenuHandle    *nextMenu;
  661.         short            i;
  662.         
  663.         // Create a temporary paper type
  664.         
  665.         paper = GXNewPaperType(theJob, NULL, NULL, NULL);
  666.         anErr = GXGetJobError(theJob);
  667.         require(anErr == noErr, NewPaperType);
  668.         
  669.         // For each visible pop-up menu, try to display the last choosen paper type
  670.         
  671.         for (i = kTray1Item, nextMenu = &(menuStuff->tray1Menu); i <= kTray3Item; ++i, ++nextMenu )
  672.         {
  673.             short        whichTray = i - kTray1Item + 1;
  674.             
  675.             if ( whichTray <= menuStuff->numTrays )    //    T => This menu is visible
  676.             {
  677.                 Str255    menuString;
  678.                 short        j;
  679.                 Str31        paperName;
  680.                 
  681.                 // Get the tray information for this tray
  682.                 
  683.                 anErr = GXGetTrayPaperType(whichTray, paper);
  684.                 if (anErr == resNotFound)
  685.                     anErr = noErr;
  686.                 else {
  687.                     require(anErr == noErr, GetTrayPaperType);
  688.                 
  689.                     // Fetch the name of the paper type
  690.                     GXGetPaperTypeName(paper, paperName);
  691.                     
  692.                     // For each paper name in the menu, try to find a match
  693.                     
  694.                     for (j = CountMItems(*nextMenu); j > 0; --j) 
  695.                     {
  696.                         GetItem(*nextMenu, j, menuString);
  697.                         
  698.                         if ( IUCompString(paperName, menuString) == 0 )     //    T => Found the string
  699.                         {
  700.                             //    Make this paper name the current pop-up menu selection
  701.                             
  702.                             GetDItem(dLog, i, &itemType, &hItem, &itemRect);
  703.                             SetCtlValue((ControlHandle) hItem, j);
  704.                             break;
  705.                         }
  706.                     }
  707.                 }
  708.             }
  709.             else    //     T => No more visible pop-up menus
  710.                 break;
  711.         }
  712.  
  713.         // Dump the temporary paper type
  714.         GXDisposePaperType(paper);
  715.     }
  716.     
  717.     *theDlog = dLog;
  718.     
  719.     return(anErr);
  720.     
  721.     
  722. /******* Clean-up *******/
  723.  
  724. GetTrayPaperType:
  725.     GXDisposePaperType(paper);
  726.  
  727. NewPaperType:
  728. LoadPaperNames:
  729.     DisposHandle((Handle) (*hGlobals)->sheetFeederPICT);
  730.     
  731. FetchTaggedDriverData:
  732. GetConfigInfo:
  733.     DisposDialog(dLog);
  734.     
  735. GetNewDialog:
  736.     return(anErr);
  737. }
  738. /* InitSheetfeederDialog */
  739.  
  740.  
  741. /***************************************************************************************
  742. *                                         INTERFACE ROUTINES                                                     *
  743. ***************************************************************************************/                        
  744.  
  745. /****************************************************************************************
  746.  
  747.                             DoSheetfeederDialog
  748.                             
  749.     function:
  750.                 This routine is called to display and process the LQ driver's sheetfeeder
  751.                 dialog.  This dialog is displayed when the user selects the "Input Trays…" menu
  752.                 item from the Finder menu.  This dialog allows the user to specify the type
  753.                 of paper that's contained within the printer's sheet feeder.
  754.                 
  755.     parameters:                
  756.                 None
  757.                 
  758.     returns:
  759.                 OSErr        error code
  760.     
  761. ****************************************************************************************/
  762. OSErr DoSheetfeederDialog(void)
  763. {
  764.     OSErr                    anErr = noErr;
  765.     GrafPtr                oldPort;
  766.     DialogPtr            theDlog;
  767.     short                    itemHit = 0;
  768.     PopupMenuInfo        menuStuff;
  769.     SpecGlobalsHdl     hGlobals = GetMessageHandlerInstanceContext();
  770.     
  771.     GetPort(&oldPort);
  772.     
  773.     // Initialize the dialog before displaying it
  774.     anErr = InitSheetfeederDialog(&theDlog, &menuStuff);
  775.     require(anErr == noErr, InitSheetfeederDialog);
  776.     
  777.     // Make sure the dialog is now visible
  778.     ShowWindow(theDlog);
  779.     SelectWindow(theDlog);
  780.     
  781.     // Process events in the window
  782.     while ( (itemHit != ok) && (itemHit != cancel) )
  783.     {
  784.        ModalDialog((ModalFilterProcPtr) SheetfeederDialogFilter, &itemHit);
  785.     }
  786.  
  787.     //    Do we need to save the new settings?
  788.     if (itemHit == ok)
  789.         anErr = SaveSheetfeederSettings(theDlog, &menuStuff);
  790.         
  791.     // Dump the dialog and picture handle
  792.     
  793.     if ( (*hGlobals)->sheetFeederPICT != nil )
  794.         DisposHandle((Handle) (*hGlobals)->sheetFeederPICT);
  795.         
  796.     DisposDialog(theDlog);
  797.     
  798.     SetPort(oldPort);
  799.  
  800.     return(anErr);
  801.     
  802.     
  803. /******* Clean-up *******/
  804.  
  805. InitSheetfeederDialog:
  806.     SetPort(oldPort);
  807.     
  808.     return(anErr);
  809. }
  810. /* DoSheetfeederDialog */
  811.  
  812.